Two things. One, it's OK for the expression to be subject to drop scope extension. It's not OK for that extension to extend the scope outside of the initializer to the end of the program.

const _: () = { let x = { &mut 0u8 }; x; }; //~ OK
//                             ^^^
// The drop scope of this temporary is extended.

Two, the comma in "..., and which are either..." causes me to read it as a clause independent from "except...". I.e., this says (applying commutativity) "all forms of borrows 1) that are either mutable or result in values with interior mutability and 2) where the expression would not be subject to drop scope extension".

d261499

@traviscross -- did this address the issue raised?

This is correct, except that, if I'm reading the diff correctly, it's putting this language in the list of what constitutes a constant context rather than about what constitutes a constant expression. We're defining constant expressions here, and the existing rules about "borrows" and "immutable borrow expressions" will need to be changed (and then that reflected in the changelog, etc.).

7577c69 and 83a05c6

Two things. One, even with the other rule, this needs to talk about containing a mutable reference rather than being one.

Two, it's not enough to talk about types here. We actually do this reasoning by value, not by type.

trait Tr {}
impl<T: ?Sized> Tr for T {}
static mut X: u8 = 0;
const _: &dyn Tr = unsafe { &&mut X }; //~ ERROR
//       ^^^^^^^
// This type does not contain any mutable references.

am not sure how to word this simply, given the complexities

I will give this a shot.

The paragraph

The type of a :t:constant cannot be a :t:mutable reference type.

should be removed.

Insert the following after
7.1:8 The value of a constant is determined by evaluating its constant initializer.

The value of a constant cannot contain any mutable references, except when:

• The type of the constant is an immutable reference and the initializer contains a reference to a mutable static, or
• The type of the constant is subject to interior mutability and the initializer contains a reference to a value subject to interior mutability, or
• The type of the constant is a zero-sized type and the initializer contains a reference to a value of a zero-sized type, or
• The initializer contains a reference to an external static.

I am not sure whether the type of the constant plays a role in the external static case.

The value of a constant cannot contain any mutable references, except when... The initializer contains a reference to an external static.

unsafe extern "C" {
    safe static S1: u8;
}

static mut S2: u8 = 0;

const C: (&u8, &mut u8) = (&S1, unsafe { &mut S2 }); //~ ERROR
//                         ^^^
// The initializer contains a reference to an external static.

Similarly:

The value of a constant cannot contain any mutable references, except when... The type of the constant is an immutable reference and the initializer contains a reference to a mutable static...

static mut S1: u8 = 0;
static mut S2: u8 = 0;

const C: &(&u8, &mut u8) = unsafe { &(&S1, &mut S2) }; //~ ERROR
//       ^                            ^^^
// The type of the constant is an immutable reference and the
// initializer contains a reference to a mutable static.

@tshepang Here is the wording we arrived at during our FLS team meeting on 2025-11-14:

The final value of a constant, after the constant initializer is evaluated to a value of the declared type, cannot contain any mutable references except when

• The mutable reference is contained within an external static, or
• The mutable reference is contained within a mutable static or a static whose type is subject to interior mutability, or
• The mutable reference is contained within an union, or
• The referent is a value of a zero-sized type.

70bef35

used "after type coercion" instead of "final value" (since the latter is not defined anywhere), then adjusted the sentence a bit due to that, so that it is more pleasant to read

one more thing, do we need the first part of the sentence, "After a constant initializer is evaluated to a value of the declared type", given that the sentence preceding it says "The value of a constant is determined by evaluating its constant initializer"

No, we do not.

c8bb9c9